
/* 
其中删除是软删除，即只是将状态改为删除，而数据仍然存在，方便数据恢复,这个是下架农产品的功能，用户可以重新上架。
即便下架了再查询自己的商品的时候，也会显示在自己的商品列表中。但是不会在产品集市中显示。
 */
const { console } = require('inspector');
const AgriDao = require('../database/AgriDao');
// const upload = require('../config/multerConfig');
const path=require('path');
class AgriController {
    constructor(pool) {
        this.pool = pool;
        this.agriDao = new AgriDao(pool);
    }

    // 根据id获取产品信息
    async getProductById(req, res) {
        const { product_id } = req.query; // 获取传入的product_id
        const { userId } = req.user; // 获取userId

        try {
            const product = await this.agriDao.getProductById(product_id, userId);  
            if (!product) {
                return res.status(404).json({ code: 404, msg: '产品未找到' });
            }
            res.json({ code: 200, msg: '操作成功', data: product });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }

    // 下架农产品（软删除）
    async deactivateProduct(req, res) {
        const { product_id } = req.body;
        const { userId } = req.user;

        try {
            // 调用dao方法进行软删除
            const result = await this.agriDao.deactivateProduct(product_id, userId);
            if (result.affectedRows === 0) {
                return res.status(404).json({ code: 404, msg: '未找到要下架的产品' });
            }
            res.json({ code: 200, msg: '产品下架成功'  ,data:null});
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }

    // 重新上架农产品
    async reactivateProduct(req, res) {
        const { product_id } = req.body;
        const { userId } = req.user;

        try {
            // 调用dao方法进行恢复上架
            const result = await this.agriDao.reactivateProduct(product_id, userId);
            if (result.affectedRows === 0) {
                return res.status(404).json({ code: 404, msg: '未找到要恢复的产品' });
            }
            res.json({ code: 200, msg: '产品上架成功',data:null });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }

    // 获取当前用户的农产品列表（包括已下架的）
    async getUserProducts(req, res) {
        const { userId } = req.user;

        try {
            const products = await this.agriDao.getUserProducts(userId);
            res.json({ code: 200, msg: '操作成功', data: products });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }
    // 根据标题搜索农产品
    async searchProductsByTitle(req, res) {
        const { title, role } = req.query;  // 获取传入的title和role
        const { userId } = req.user;  // 获取userId

        try {
            const products = await this.agriDao.searchProductsByTitle(title, role, userId);
            res.json({ code: 200, msg: '操作成功', data: products });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }
    // 获取政府的农产品接口
    async getGovernmentProducts(req, res) {
        try {
            // 获取政府发布的所有农产品
            const products = await this.agriDao.getGovernmentProducts();
            res.json({ code: 200, msg: '操作成功', data: products });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }

    // 获取农户的农产品接口
    async getFarmerProducts(req, res) {
        try {
            // 获取农户发布的所有农产品
            const products = await this.agriDao.getFarmerProducts();
            res.json({ code: 200, msg: '操作成功', data: products });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }

    // 根据产品名称和角色筛选公告
    async searchProduct(req, res) {
        const { title, role } = req.query; // 获取请求参数 title 和 role
        if (!title || !role) {
            return res.status(400).json({ code: 400, msg: '缺少必要的查询参数' });
        }

        try {
            const products = await this.agriDao.searchProductAnnouncements(title, role);
            res.json({ code: 200, msg: '操作成功', data: products });
        } catch (error) {
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
        }
    }
    async createAgriProduct(req, res) {
        //const { userId } = req.user; // 获取 userId
        // const userId=1;
        const {
          userId,
          product_name,
          category,
          region,
          price,
          total_stock,
          listed_quantity,
          description,
          introduction
        } = req.body;
        try {
          // 检查是否缺少必要字段
          if (!product_name || !category || !region || !price || !total_stock || !listed_quantity) {
            return res.status(400).json({ code: 400, msg: '缺少必要字段' });
          }
          // 发布农产品
          const result = await this.agriDao.createAgriProduct(
            product_name,
            category,
            region,
            price,
            total_stock,
            listed_quantity,
            description,
            userId,
            introduction
          );

          // 获取新创建的产品信息
          const newProduct = await this.agriDao.getProductById(result.insertId,userId);
          console.log('新创建的产品信息:', newProduct);
          res.json({
            code: 200,
            msg: '添加成功',
            data: {
              product_id: newProduct.product_id,
              user_id: newProduct.user_id,
              product_name: newProduct.product_name,
              category: newProduct.category,
              region: newProduct.region,
              price: newProduct.price,
              total_stock: newProduct.total_stock,
              listed_quantity: newProduct.listed_quantity,
              status : newProduct.status ,
              description: newProduct.description,
              introduction : newProduct.introduction,
              created_at: newProduct.created_at,
            }
          });
        } catch (err) {
          console.error(err);
          res.status(500).json({ code: 500, msg: '服务器错误', error: err.message });
        }
      }
      async createAgriProductImg(req, res) {
        const  product_id  = req.body.product_id;
        if (!product_id) {
          return res.status(400).json({ code: 400, msg: '缺少参数' });
        }
        if (!req.file) {
            return res.status(400).send('No file uploaded.');
        }

        const imageUrl = `${path.basename(req.file.path)}`;
        console.log(imageUrl);
        // 返回图片 URL

        try {
            // 插入图片 URL 到 product_images 表
            await this.agriDao.insertProductImage(product_id, imageUrl);
      
            // 返回图片 URL
            res.status(200).json({
              code: 200,
              msg: 'File uploaded successfully.',
              data: imageUrl
            });
          } catch (error) {
            console.error(error);
            res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
          }
      }

      async createAgriWithImg(req, res) {
        const productData = JSON.parse(req.body.productData);
           const userId=productData.userId;
           const product_name=productData.product_name;
           const category = productData.category;
           const region=productData.region;
           const price=productData.price;
           const total_stock=productData.total_stock;
           const listed_quantity=productData.listed_quantity;
           const description=productData.description;
           const introduction=productData.introduction;
          console.log(userId);
          try {
            // 检查是否缺少必要字段
            if (!product_name || !category || !region || !price || !total_stock || !listed_quantity) {
              return res.status(400).json({ code: 400, msg: '缺少必要字段' });
            }
            // 发布农产品
            const result = await this.agriDao.createAgriProduct(
              product_name,
              category,
              region,
              price,
              total_stock,
              listed_quantity,
              description,
              userId,
              introduction
            );
            const  product_id  = result.insertId;
            if (!product_id) {
            return res.status(400).json({ code: 400, msg: '缺少参数' });
            }
            if (!req.file) {
                return res.status(400).send('No file uploaded.');
            }

            // 生成图片的 URL  http://${req.headers.host}/images/重复，不加入数据库
            const Url = `${path.basename(req.file.path)}`;
            const imageUrl ="http://159.75.133.177:8080/images/"+Url;
            console.log(imageUrl);
            try {
                // 插入图片 URL 到 product_images 表
                await this.agriDao.insertProductImage(product_id, imageUrl);
              } catch (error) {
                console.error(error);
                res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
              }
            // 获取新创建的产品信息
            const newProduct = await this.agriDao.getProductById(result.insertId,userId);
            console.log('新创建的产品信息:', newProduct);
            res.json({
              code: 200,
              msg: '添加成功',
              data: {
                product_id: newProduct.product_id,
                user_id: newProduct.user_id,
                product_name: newProduct.product_name,
                category: newProduct.category,
                region: newProduct.region,
                price: newProduct.price,
                total_stock: newProduct.total_stock,
                listed_quantity: newProduct.listed_quantity,
                status : newProduct.status ,
                description: newProduct.description,
                introduction : newProduct.introduction,
                created_at: newProduct.created_at,
                images: imageUrl
              }
            });
          } catch (err) {
            console.error(err);
            res.status(500).json({ code: 500, msg: '服务器错误', error: err.message });
          }
        
      }

      async createAgriWithImgs(req, res) {
        const productData = JSON.parse(req.body.productData);
        const userId = productData.userId;
        const product_name = productData.product_name;
        const category = productData.category;
        const region = productData.region;
        const price = productData.price;
        const total_stock = productData.total_stock;
        const listed_quantity = productData.listed_quantity;
        const description = productData.description;
        const introduction = productData.introduction;
        console.log(userId);
        try {
            // 检查是否缺少必要字段
            if (!product_name || !category || !region || !price || !total_stock || !listed_quantity) {
                return res.status(400).json({ code: 400, msg: '缺少必要字段' });
            }
            // 发布农产品
            const result = await this.agriDao.createAgriProduct(
                product_name,
                category,
                region,
                price,
                total_stock,
                listed_quantity,
                description,
                userId,
                introduction
            );
            const product_id = result.insertId;
            if (!product_id) {
                return res.status(400).json({ code: 400, msg: '缺少参数' });
            }
            if (!req.files || req.files.length === 0) {
                return res.status(400).send('No files uploaded.');
            }
    
            const imageUrls = [];
            for (const file of req.files) {
                // 生成图片的 URL
                const Url = `${path.basename(file.path)}`;
                const imageUrl = `http://159.75.133.177:8080/images/${Url}`;
                imageUrls.push(imageUrl);
    
                try {
                    // 插入图片 URL 到 product_images 表
                    await this.agriDao.insertProductImage(product_id, imageUrl);
                } catch (error) {
                    console.error(error);
                    await this.agriDao.deleteProductById(product_id); // 删除刚创建的产品
                    res.status(500).json({ code: 500, msg: '服务器错误', error: error.message });
                    return;
                }
            }
    
            //获取新创建的产品信息
            const newProduct = await this.agriDao.getProductById(result.insertId, userId);
            console.log('新创建的产品信息:', newProduct);
            res.json({
                code: 200,
                msg: '添加成功',
                data: {
                    product_id: newProduct.product_id,
                    user_id: newProduct.user_id,
                    product_name: newProduct.product_name,
                    category: newProduct.category,
                    region: newProduct.region,
                    price: newProduct.price,
                    total_stock: newProduct.total_stock,
                    listed_quantity: newProduct.listed_quantity,
                    status: newProduct.status,
                    description: newProduct.description,
                    introduction: newProduct.introduction,
                    created_at: newProduct.created_at,
                    images: imageUrls
                }
            });
        } catch (err) {
            console.error(err);
            res.status(500).json({ code: 500, msg: '服务器错误', error: err.message });
        }
    }

}

module.exports = AgriController;
